//#pragma once
//
//#include <iostream>
//#include <assert.h>
//#include <string.h>
//#include <string>
//using namespace std;
//
//using namespace std;
//
//namespace A
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		typedef const char* const_iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//		iterator end()
//		{
//			return _str + _size;
//		}
//		const_iterator begin() const
//		{
//			return _str;
//		}
//		const_iterator end() const
//		{
//			return _str + _size;
//		}
//		string(const char* str = "")
//			:_size(strlen(str))
//			,_capacity(_size)
//		{
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);			
//		}
//		
//		void swap(string& s)
//		{
//			std::swap(_str, s._str);
//			std::swap(_size, s._size);
//			std::swap(_capacity, s._capacity);
//		}
//		string(const string& s)
//			:_str(nullptr)
//			,_size(0)
//			,_capacity(0)
//		{
//			string tmp(s._str);
//			swap(tmp);
//		}
//
//		string& operator=(string tmp)
//		{
//			if(this != &tmp)
//				swap(tmp);
//			return *this;
//		}
//
//
//			
//		/*string& operator=(const string& s)
//		{
//			if (this != &s)
//			{
//				string tmp(s);
//				swap(tmp);
//			}
//			return *this;
//		}*/
//
//		/*string(const string& s)
//			:_size(strlen(s._str))
//			,_capacity(_size)
//		{
//			_str = new char[_capacity + 1];
//			strcpy(_str, s._str);
//		}
//
//		string& operator=(const string& s)
//		{
//			if (this != &s)
//			{
//				char* tmp = new char[s._capacity + 1];
//				strcpy(tmp, s._str);
//				delete[] _str;
//				_str = tmp;
//
//				_size = s._size;
//				_capacity = s._capacity;
//			}
//			return *this;
//		}*/
//
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//			_size = _capacity = 0;
//		}
//
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//		const char& operator[](size_t pos) const
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//
//		string& operator+=(const string& s)
//		{
//			append(s._str);
//			return *this;
//		}
//		string& operator+=(const char s)
//		{
//			push_back(s);
//			return *this;
//		}
//		
//		size_t size() const
//		{
//			return _size;
//		}
//
//		const char* c_str() const
//		{
//			return _str;
//		}
//		void clear()
//		{
//			_size = 0;
//			_str[_size] = '\0';
//		}
//
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//			}
//			_capacity = n;
//		}
//
//		void push_back(char ch)
//		{
//			if (_size == _capacity)
//			{
//				reserve(_capacity * 2);
//			}
//			_str[_size++] = ch;
//			_str[_size + 1] = '\0';
//		}
//
//		void append(const char* str)
//		{
//			size_t n = strlen(str);
//			if (n + _size > _capacity)
//			{
//				reserve(n + _size);
//			}
//			strcpy(_str + n, str);
//			_size += n;
//		}
//
//		string& insert(size_t pos, const char* str)
//		{
//			assert(pos <= _size);
//			size_t len = strlen(str);
//			if (_size + len > _capacity)
//			{
//				reserve(_size + len);
//			}
//			size_t end = _size;
//			while (end >= pos)
//			{
//				_str[end + len] = _str[end];
//				end--;
//			}
//			while (*str != '\0')
//			{
//				_str[pos + 1] = *str;
//				str++;
//				pos++;
//			}
//			_size += len;
//			return *this;
//		}
//
//		string& erase(size_t pos = 0, size_t len = npos)
//		{
//			assert(pos <= _size);
//			if (len == npos || len + pos >= _size)
//			{
//				_str[pos] = '\0';
//				_size = pos;
//			}
//			else
//			{
//				size_t begin = pos + len;
//				while (begin <= _size)
//				{
//					_str[pos] = _str[begin];
//					pos++;
//					begin++;
//				}
//				_size = pos;
//			}
//			return *this;
//		}
//
//		void resize(size_t n, char ch = ' ')
//		{
//			if (n > _size)
//			{
//				reserve(n);
//				while (_size < n)
//				{
//					_str[_size++] = ch;
//				}
//				_str[_size] = '\0';
//			}
//			else
//			{
//				_str[n] = '\0';
//				_size = n;
//			}
//		}
//
//		size_t find(char ch, size_t pos = 0) const
//		{
//			assert(pos < _size);
//			while (pos < _size)
//			{
//				if (_str[pos] == ch)
//				{
//					return pos;
//				}
//				pos++;
//			}
//			return npos;
//		}
//
//		size_t find(const char* sub, size_t pos = 0)
//		{
//			assert(pos < _size);
//			const char* p = strstr(_str + pos, sub);
//			if (p != NULL)
//			{
//				return p - _str;
//			}
//			else
//			{
//				return npos;
//			}
//		}
//
//		string substr(size_t pos, size_t len = npos) const
//		{
//			string s;
//			size_t end = pos + len;
//			if (pos + len >= _size || len == npos)
//			{
//				len = _size - pos;
//				end = _size;
//			}
//			s.reserve(len);
//
//			for (int i = pos; i < end; i++)
//			{
//				s += _str[i];
//			}
//			return s;
//		}
//
//	private:
//		char* _str;
//		int _size;
//		int _capacity;
//		static const size_t npos;
//	};
//	const size_t string::npos = -1;
//
//	ostream& operator<<(ostream& out, const string& str)
//	{
//		for (int i = 0; i < str.size(); i++)
//		{
//			out << str[i];
//		}
//		return out;
//	}
//
//	istream& operator>>(istream& in, string& s)
//	{
//		s.clear();
//
//		char ch;
//		ch = in.get();
//		while (ch != ' ' && ch != '\n')
//		{
//			s += ch;
//			ch = in.get();
//		}
//		return in;
//	}
//
//
//
//	void test_string1()
//	{
//		string s("hello");
//		s.resize(7, 's');
//		cout << s << endl;
//
//		s.resize(2);
//		cout << s << endl;
//	}
//}